{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import re\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from pylab import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pythonlib import boolean as boolean\n",
    "from pythonlib import boolean_net as boolean_net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random as random #random could be destroyed by matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_bool_charactor(c):\n",
    "    if c=='1':\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_bool_string(s):\n",
    "    return[to_bool_charactor(x) for x in s]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def file2matrix(path):\n",
    "    fp=open(path,'r')\n",
    "    content=fp.read()\n",
    "    rowlist=content.splitlines()\n",
    "    x=np.array([to_bool_string(x) for x in rowlist])\n",
    "    \n",
    "    return x\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_bool_dict={0:[False,False,False,False],\n",
    "              1:[False,False,False,True],\n",
    "              2:[False,False,True,False],\n",
    "              3:[False,False,True,True],\n",
    "              4:[False,True,False,False],\n",
    "              5:[False,True,False,True],\n",
    "              6:[False,True,True,False],\n",
    "              7:[False,True,True,True],\n",
    "              8:[True,False,False,False],\n",
    "              9:[True,False,False,True]}\n",
    "             \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool_list=list(num_bool_dict.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_char_bool(bool):\n",
    "    if bool:\n",
    "        return '1'\n",
    "    else:\n",
    "        return '0'\n",
    "\n",
    "def to_string_boollist(boollist):\n",
    "    temp=[to_char_bool(x) for x in boollist]    \n",
    "    return ''.join(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_nn(bl1):\n",
    "    fig,axs=plt.subplots(nrows=1, ncols=5, figsize=(12, 6))\n",
    "    axs[0].imshow(np.array([bl1.inode]),vmin=0,vmax=1)\n",
    "    axs[0].set_title('inode')\n",
    "    axs[0].set_axis_off()\n",
    "    axs[1].imshow(bl1.wi,vmin=0,vmax=1)\n",
    "    axs[1].set_title('wi')\n",
    "    axs[1].set_axis_off()\n",
    "    axs[2].imshow(np.array([bl1.hnode]),vmin=0,vmax=1)\n",
    "    axs[2].set_title('hnode')\n",
    "    axs[2].set_axis_off()\n",
    "    axs[3].imshow(bl1.wo,vmin=0,vmax=1)\n",
    "    axs[3].set_title('wo')\n",
    "    axs[3].set_axis_off()\n",
    "    axs[4].imshow(np.array([bl1.onode]),vmin=0,vmax=1)\n",
    "    axs[4].set_title('onode')\n",
    "    axs[4].set_axis_off()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_nparray(nparray):\n",
    "    fig,axs=plt.subplots(nrows=1, ncols=1)\n",
    "    axs.imshow((nparray),vmin=0,vmax=1)\n",
    "    axs.set_title('array')\n",
    "    axs.set_axis_off()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "root = \"trainingDigits16x\" #数据文件所在路径\\n\"\n",
    "pathlist = os.listdir(root) # 获取路径下所有数据文件\"\n",
    "\n",
    "random.shuffle(pathlist)\n",
    "test_set=[]\n",
    "tag=3\n",
    "for i in range (0,128):\n",
    "    filepath=root+'\\\\'+pathlist[i]\n",
    "    s=pathlist[i]\n",
    "    n=(re.split('_',s))[0]\n",
    "    target=num_bool_dict[int(n)]\n",
    "    if int(n)==tag:\n",
    "        input=file2matrix(filepath).reshape(1,256).tolist()[0]\n",
    "        #print(filepath)\n",
    "        test_set.append([input,target])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "    \n",
    "random.shuffle(pathlist)\n",
    "verify_set=[]\n",
    "for i in range (0,128):\n",
    "    filepath=root+'\\\\'+pathlist[i]\n",
    "    s=pathlist[i]\n",
    "    n=(re.split('_',s))[0]\n",
    "    target=num_bool_dict[int(n)]\n",
    "    if int(n)==tag:\n",
    "        input=file2matrix(filepath).reshape(1,256).tolist()[0]\n",
    "        #print(filepath)\n",
    "        verify_set.append([input,target]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.shuffle(pathlist)\n",
    "verify_set=[]\n",
    "for i in range (0,64):\n",
    "    filepath=root+'\\\\'+pathlist[i]\n",
    "    s=pathlist[i]\n",
    "    n=(re.split('_',s))[0]\n",
    "    target=num_bool_dict[int(n)]\n",
    "\n",
    "    input=file2matrix(filepath).reshape(1,256).tolist()[0]\n",
    "    #print(filepath)\n",
    "    verify_set.append([input,target]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "64\n"
     ]
    }
   ],
   "source": [
    "print(len(test_set))\n",
    "print(len(verify_set))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#train\n",
    "bl1=boolean_net.booleannet('bl.db',256,8,4)\n",
    "bl1_mirr=boolean_net.booleannet('bl.db',256,8,4)\n",
    "random.shuffle(test_set)\n",
    "for j in test_set:\n",
    "    inputs=j[0]\n",
    "    targets=j[1]\n",
    "    for i in range(0,2):\n",
    "        bl1.train(inputs,targets)\n",
    "        bl1.feedforward()\n",
    "        #show_nn(bl1)\n",
    "        #copy weight matrix\n",
    "        bl1_mirr.wi=bl1.wo.T\n",
    "        bl1_mirr.wo=bl1.wi.T\n",
    "        #target as inputs\n",
    "        bl1_mirr.train(targets,inputs)\n",
    "        bl1_mirr.feedforward()\n",
    "        #show_nn(bl1_mirr)\n",
    "\n",
    "        bl1.wi=bl1_mirr.wo.T\n",
    "        bl1.wo=bl1_mirr.wi.T\n",
    "        bl1.feedforward()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#train\n",
    "bl1=boolean_net.booleannet('bl.db',256,8,4)\n",
    "#bl1_mirr=boolean_net.booleannet('bl.db',256,8,4)\n",
    "random.shuffle(test_set)\n",
    "for j in test_set:\n",
    "    inputs=j[0]\n",
    "    targets=j[1]\n",
    "    for i in range(0,2):\n",
    "        bl1.train(inputs,targets)\n",
    "        bl1.feedforward()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "target:  5   result:  not_in_list  wrong\n",
      "target:  9   result:  2  wrong\n",
      "target:  7   result:  not_in_list  wrong\n",
      "target:  5   result:  3  wrong\n",
      "target:  9   result:  3  wrong\n",
      "target:  1   result:  2  wrong\n",
      "target:  2   result:  3  wrong\n",
      "target:  9   result:  3  wrong\n",
      "target:  4   result:  5  wrong\n",
      "target:  1   result:  not_in_list  wrong\n",
      "target:  5   result:  not_in_list  wrong\n",
      "target:  6   result:  not_in_list  wrong\n",
      "target:  2   result:  3  wrong\n",
      "target:  9   result:  not_in_list  wrong\n",
      "target:  9   result:  not_in_list  wrong\n",
      "target:  4   result:  2  wrong\n",
      "target:  1   result:  not_in_list  wrong\n",
      "target:  7   result:  not_in_list  wrong\n",
      "target:  2   result:  3  wrong\n",
      "target:  1   result:  2  wrong\n",
      "target:  8   result:  not_in_list  wrong\n",
      "target:  6   result:  3  wrong\n",
      "target:  9   result:  2  wrong\n",
      "target:  8   result:  not_in_list  wrong\n",
      "target:  9   result:  not_in_list  wrong\n",
      "target:  9   result:  0  wrong\n",
      "target:  7   result:  3  wrong\n",
      "target:  2   result:  3  wrong\n",
      "target:  4   result:  not_in_list  wrong\n",
      "target:  0   result:  4  wrong\n",
      "target:  8   result:  0  wrong\n",
      "target:  1   result:  not_in_list  wrong\n",
      "target:  6   result:  3  wrong\n",
      "target:  2   result:  3  wrong\n",
      "target:  4   result:  2  wrong\n",
      "target:  2   result:  not_in_list  wrong\n",
      "target:  8   result:  not_in_list  wrong\n",
      "target:  5   result:  3  wrong\n",
      "target:  1   result:  3  wrong\n",
      "target:  0   result:  3  wrong\n",
      "target:  4   result:  2  wrong\n",
      "target:  4   result:  not_in_list  wrong\n",
      "target:  7   result:  not_in_list  wrong\n",
      "target:  9   result:  not_in_list  wrong\n",
      "target:  0   result:  3  wrong\n",
      "target:  6   result:  2  wrong\n",
      "target:  1   result:  not_in_list  wrong\n",
      "target:  6   result:  3  wrong\n",
      "target:  8   result:  3  wrong\n",
      "target:  3   result:  not_in_list  wrong\n",
      "target:  3   result:  2  wrong\n",
      "target:  7   result:  3  wrong\n",
      "target:  2   result:  2  right\n",
      "target:  6   result:  2  wrong\n",
      "target:  4   result:  not_in_list  wrong\n",
      "target:  9   result:  0  wrong\n",
      "target:  8   result:  2  wrong\n",
      "target:  6   result:  3  wrong\n",
      "target:  6   result:  3  wrong\n",
      "target:  5   result:  2  wrong\n",
      "target:  9   result:  3  wrong\n",
      "target:  2   result:  2  right\n",
      "target:  5   result:  2  wrong\n",
      "target:  6   result:  3  wrong\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#test\n",
    "right=0\n",
    "right_list=[]\n",
    "for i in verify_set:\n",
    "    bl1.inode=i[0]\n",
    "    bl1.feedforward()\n",
    "    target = bool_list.index(i[1])\n",
    "    try:\n",
    "        result = bool_list.index(bl1.onode)\n",
    "    except:\n",
    "        result ='not_in_list'\n",
    "    #print()    \n",
    "    if bl1.onode==i[1]:\n",
    "        print('target: ',target , '  result: ',result,' right')\n",
    "        right_list.append(target)\n",
    "        right+=1\n",
    "    else:\n",
    "        print('target: ',target , '  result: ',result,' wrong')\n",
    "right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(bl1.onode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_id_blnn(blnn_set,num,inputs,targets):\n",
    "    blnn_set[num].train(inputs,targets)\n",
    "    blnn_set[num].feedforward()\n",
    "        #flip training\n",
    "    inode_len=len(blnn_set[num].inode)\n",
    "    hnode_len=len(blnn_set[num].hnode)\n",
    "    onode_len=len(blnn_set[num].onode)\n",
    "    #creat bl1_mirr\n",
    "    bl1_mirr=boolean_net.booleannet('bl.db',onode_len,hnode_len,inode_len)\n",
    "    #\n",
    "    inputs_flip=[not(x) for x in inputs]\n",
    "    targets_flip=[not(x) for x in targets]\n",
    "    #copy weight matrix\n",
    "    bl1_mirr.wi=blnn_set[num].wo.T\n",
    "    bl1_mirr.wo=blnn_set[num].wi.T\n",
    "    #target as inputs\n",
    "    bl1_mirr.train(targets_flip,inputs_flip)\n",
    "    bl1_mirr.feedforward()\n",
    "    #show_nn(bl1_mirr)\n",
    "\n",
    "    blnn_set[num].wi=bl1_mirr.wo.T\n",
    "    blnn_set[num].wo=bl1_mirr.wi.T\n",
    "    blnn_set[num].inode=inputs\n",
    "    blnn_set[num].feedforward()\n",
    "\n",
    "def verify(blnn,inputs,targets):\n",
    "    blnn.inode=inputs\n",
    "    blnn.feedforward()\n",
    "    if blnn.onode==targets:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "def if_num(flag,num):\n",
    "    if flag:\n",
    "        return num\n",
    "    else:\n",
    "        pass\n",
    "\n",
    "num_list=[0,1,2,3,4,5,6,7,8,9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "root = \"trainingDigits\" #数据文件所在路径\\n\"\n",
    "pathlist = os.listdir(root) # 获取路径下所有数据文件\"\n",
    "\n",
    "random.shuffle(pathlist)\n",
    "train_set=[]\n",
    "\n",
    "for i in range (0,128):\n",
    "    filepath=root+'\\\\'+pathlist[i]\n",
    "    s=pathlist[i]\n",
    "    n=(re.split('_',s))[0]\n",
    "    targets=num_bool_dict[int(n)]\n",
    "\n",
    "    inputs=file2matrix(filepath).flatten().tolist()\n",
    "    #print(filepath)\n",
    "    train_set.append([inputs,targets,int(n)])\n",
    "\n",
    "random.shuffle(pathlist)\n",
    "verify_set=[]\n",
    "for i in range (0,64):\n",
    "    filepath=root+'\\\\'+pathlist[i]\n",
    "    s=pathlist[i]\n",
    "    n=(re.split('_',s))[0]\n",
    "    targets=num_bool_dict[int(n)]\n",
    "\n",
    "    inputs=file2matrix(filepath).flatten().tolist()\n",
    "    #print(filepath)\n",
    "    verify_set.append([inputs,targets,int(n)]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "blnn_set=[]\n",
    "\n",
    "for i in range(0,10):\n",
    "    blnntemp=boolean_net.booleannet('bl.db',1024,16,4)\n",
    "    blnn_set.append(blnntemp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "#train\n",
    "random.shuffle(train_set)\n",
    "for i in train_set:\n",
    "    inputs,targets,num=i\n",
    "    train_id_blnn(blnn_set,num,inputs,targets)\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqwAAAA7CAYAAAC+PtjiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAALr0lEQVR4nO3dfYxc113G8e9zZ2ZfvH5/SRzXzmshaZGKi1I1LeQFiVLSpuGPkpKWNm3Ki4REkEohQghKWloIEimobSIhVFqapkBDi9Q0llKjkiUBKS0QWhFw4hLZ3cQ22bW93vV6d2fn3h9/nDtiusquo/XOzvX4+Ugjz527584542vvc8+ce44iAjMzMzOzqsp6XQEzMzMzs+U4sJqZmZlZpTmwmpmZmVmlObCamZmZWaU5sJqZmZlZpTmwmpmZmVmlObCamZmZncck3SPpi72uRzc5sJqZmZlZpTmwmpmZmVmlObCamZl1gaQ7JT3SsX1Q0sMd22OS9kp6s6RvSzpV/vnm3tTYukHSayQ9LmlS0jOSbi1f/7yk+yU9Kmla0lOSruoot+R5IekKSaNluf3A9kXveZ2kfynf8zuSblqj5naNA6uZmVl3jALXS8ok7QIGgDcBSLoSWA98H3gU+BSwDfgk8Kikbb2psq0mSQ3gEeAbwEXAXcBDkq4uf+R24KPAFuB7wCfKcltZ/rz4EvBvpKD6B8D7O97zVWXZjwNbgd8EviJpR9caugYcWM3MzLogIp4HpoG9wA3AY8ARSdcANwJPAG8HDkbEgxHRioi/Bg4A7+hNrW2VXUe6MLk3IpoR8U3g68C7y/1/HxHfiogW8BDpXIFlzgtJlwJvAH4vIuYj4p9IobjtvcC+iNgXEUVE7Af+FXhbl9vaVfVeV8DMzKyPjQI3Aa8un0+Swuqbyu1dwOFFZQ4Dr1qzGlo37QLGIqLoeK3z7/dYx+tnSOG2XW6p82IXcDIiZhbt21M+vwy4TVLnRU8D+MeVNqIK3MNqZmbWPe3Aen35fJQUWG8snx8hBYxOlwIvrl0VrYuOAHskdeatV/L3u9x5cRTYImlk0b62MeDBiNjc8RiJiHtX1oRqcGA1MzPrnlHgJ4HhiHiBNAzgZ0jjEp8G9gE/LOk9kuqSfh54LelrYzv/PUXqOb1bUqO8+ekdwN+cpdyS50VEHCZ9xf9RSQOSfoIfHELyRdLQgbdKqkkaknSTpN2r3LY15cBqZmbWJRHxHHCaFFSJiCngeeCfIyKPiOPALcCHgePA3cAtETHRoyrbKoqIJilM3gxMAA8Ad0TEgbOUO9t58R7gjcAJ4PeBL3SUHQN+FvgdYJzU4/pbnOeZTxHR6zqYmZmZmS3pvE7bZmarSdIhST/V5fe4XFJI8k2vZmavkAOrmZmZmVWaA6uZmZmZVZoDq9kKSTpdrlZj/WWvpO+WyyH+bccdti9I+rCklyQdlXRnu4CkTZK+IGlc0mFJv9uexqa8S/dPJE1Iep40ITiLyn62POaLkj4uqbbGbTYzq7S+CKzl2rw3rfIxPyDpydU8pvWXiFhfrmRj/eVdpGmHrgBeB3ygfH0nsIk0cfcvAvdL2lLu+3S570rS/Jp3AO1A+8uku31fD1wL/Nyi9/s80CJNLP964KeBX1rdJpmZnd/6YtB/RPxIr+tgZn3jUxFxBEDSI6SlEg8AC8DHyiUU90k6DVwt6duk9cD3RsQ0MC3pPuB9wGdJAfjPyqlmkPRHpInkkXQxabnEzRExC8xI+lPgV4A/X6P2VlJx7IeWnMLmrbv2LlnusSP/0YXaLP+eZ7Ncnc7luN1wLp/fcm3ZXzysFR94GW/Jbrsgpjrq1nldNdnOg0ueJ33Rw2q2miTdWQaV9vZBSQ93bI9J2lve6f3q3tTSumippRKPl2F18b7tpGUPO5dR7Fx6cRdpHsTOfW2XlWWPSpqUNEkKqhedYxvMzPpKXwTW9lQ0ku6R9OVyLNl0OVTg2o6fe42kx8tfDM9IurVj3zZJX5M0JelbwFWL3uMaSfslnZD0rKR3rWETbW2NAtdLyiTtAgZI635TjlldD3y3h/Wzapkg9b52LqPYufTiUf5/je/2vrYxYB7Y3rGE4kZ/a2Rm9oP6IrAucitpybPNwNeAzwBIagCPAN8g9V7cBTwk6eqy3P3AHHAJ8MHyQVl2BNgPfKksezvwgKTXdr85ttbKcanTpK+CbwAeA45IuoY0PvGJiCh6V0OrkojIgS8Dn5C0QdJlwG+Qlkek3PfrknaXY15/u6PsUdL/SfdJ2lheJF0l6cY1boaZWaX1Y2B9MiL2lb9EHgR+tHz9OlLP2L0R0YyIb5LWan53eUfuO4GPRMRMRPwn8Fcdx7wFOBQRn4uIVkQ8DXwFuG2tGmVrbpQ0zvCG8vnjpLB6Y7lt1ukuYIa05OaTpIvbvyz3/QXpouc7wL8DX11U9g5SL/5/ASeBvyNdOJuZWakvbrpaZPH4s6FyRZldwNiinrH2OLMdpM9iuXFmbyzHl7XVSYHY+tMoaf3nK4A/BCaBXyANDfhM76pl3RQRly/avqdjc/dSPxsRJ4H3LnHMFvCh8tF2f8f+U8Cvlg8zM3sZ/RhYl3IE2CMp6witlwLPAeOkaWX2kO4Gbu9rGwNGI+Ita1VZ67lR4JPA/0bEC5KmSBcodeDpntbMzMzsAnMhBdanSD2ud5dTzvw4qQftDRGRS/oqcI+kDwKXA+8HDpVlvw7cK+l9pPGxkMY3no6I/16zFtiaiYjnymmLnii3p8pJ38fL4SZm1kUrne7pbOVWOsVUt6amqtpxqzbNlllbP45hfVkR0SQF1JtJd/U+ANwREe0e1V8jjXE9RprI+3MdZadJk3nfTuqpPQb8MTC4RtW3HoiISyLizo7tayPi5o5tRcT3elM7MzOzC0df9LB2jCX7h0WvHwLUsf0M6aaZlzvGOOnmqqXe41kWLaloZmZmZt13wfSwmpmZmdn5qS96WM3s/LDccpvL6dZYvnOx0jr10xKLyy2jaGa2mtzDamZmZmaV5h5WWxWXf/q+oB5sPFBjfiu0hoNoBPmmFo2JBgubc2qnMwYmM1rrg8EJkQ8DAc3NBeyaoxgfYuTFjOamoGjA0IQ4c0lBsaHFwLEGzZ0L0MrQfEZtTiigNitq85APwvyOHDYuwGSDxlRGa12gAoYmMhZGgvqsmL24oHFaFHXIh9JrAK2RAgQbDtZYWA/NLQVD4+l6bnZnwdBLGXMXFQwfy5jfGuQjBYMv1ciHU4dhbVYUAwEBC1sKGpMZC5sLBsdrzF81hyYGKIYKBk7WqJ0RUYOsBbM7c6IRjByqkw+SPpvjojUStNYFUQME2XxqLwWsOybmN0O+LsiakA+Bchg8IZobgywXkQVqpePE7jlifJDB8Yy5i3NqsxlDE2Jue5CvL4iBgvqJOgS0ti8wfGiAAx/7kHvOzMysMhxYbVUMnsyY35HT3ARFPVh3VMzsCUYODlBrQmtE5CMF+ayoT4u5HztDa2qAdYfrRB2K6QaNWdHcFLSGg2JDzsxIRtQLhjbNo8MDrPufARY2RAqGgvppoRxmL0ohdOT7Nea3ZtRPCwKyltACRAb5cNDckVM/VWNgUsxvDWIoR1N1sgWxsKVACxkIak3IN+TM5+k4tTkxe0lO7UzGwsagMSXqZ2ogaG0oGDheo7U+Bdd8pCCbE0PjYmi8xszuoDE2mALiVpEPQWMK8hoQEEMpLEYGRSNobcxpbSuonWiglsiaKbg3NwcLV84xeGCYU69ropn0T7eOqJ8Rc7uboAb1mVTn1nrIskhtrQ0ycjSF72xB5MMFsztFYyoj6iI7VU/ftVx2BmYazG/zqrPWv7o1XdZKrXQqrXNRtWEyZq+EA6utimc/0uUeuXd29ehmZmZWYR7DamZmZmaV5sBqZmZmZpXmIQFmtmZWOg3S/goOq61inczM+pV7WM3MzMys0hxYzczMzKzSHFjNzMzMrNI8htXMzCpnublCuzXf50rnJz1bfXox92s3Pr9+WlbYzj/uYTUzMzOzSnNgNTMzM7NKc2A1MzMzs0pzYDUzMzOzSnNgNTMzM7NKc2A1MzMzs0pTRPS6DmZmZmZmS3IPq5mZmZlVmgOrmZmZmVWaA6uZmZmZVZoDq5mZmZlVmgOrmZmZmVWaA6uZmZmZVdr/AbMJ7hsL7IivAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqwAAAA7CAYAAAC+PtjiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAALoklEQVR4nO3dfYxcV33G8e8zd2b2xa9L7OAsceKQQAKorZGCCLR5qVRKAyH9ow0ECoHQF6lSg1TSRlXVl9BCm6qFVpREQhWFEkJbUqhEiKXgimabtFKgJQU1rUlIsNlk7eD12669L7Nz59c/zp0yrLI2Xe/M3B0/H2nkuXPn3HvO7pX3mTPnnqOIwMzMzMysrCr9roCZmZmZ2ek4sJqZmZlZqTmwmpmZmVmpObCamZmZWak5sJqZmZlZqTmwmpmZmVmpObCamZmZrWOS7pT0mX7Xo5scWM3MzMys1BxYzczMzKzUHFjNzMy6QNKtkh7o2H5K0v0d25OSdkt6vaSvSTpR/Pv6/tTYukHSKyQ9LOm4pCck3Vi8/ilJd0t6UNKspMckXdpRbsXrQtIlkiaKcnuBbcvOeZWkfyvO+Q1J1/WouV3jwGpmZtYdE8DVkiqSxoE68DoASS8FNgLfBR4EPgqcB3wEeFDSef2psq0lSTXgAeDLwPnAbcB9ki4v3nIz8AFgDPg28KGi3Is4/XXxWeA/SEH1D4F3d5zzJUXZDwIvAn4D+Lyk7V1raA84sJqZmXVBRDwDzAK7gWuAh4ApSVcA1wKPAG8GnoqIeyOiGRF/C+wD3tKfWtsau4r0weSuiGhExFeALwFvL/b/Y0R8NSKawH2kawVOc11Iugh4DfC7EbEYEf9CCsVt7wT2RMSeiGhFxF7g34E3dbmtXVXtdwXMzMwG2ARwHXBZ8fw4Kay+rtgeBw4sK3MAeEnPamjdNA5MRkSr47XO3++hjtfnSOG2XW6l62IcOBYRp5bt21k8vxi4SVLnh54a8M+rbUQZuIfVzMyse9qB9eri+QQpsF5bPJ8iBYxOFwHP9a6K1kVTwE5JnXnrh/n9nu66OAiMSdqwbF/bJHBvRGzteGyIiLtW14RycGA1MzPrngngJ4GRiHiWNAzgZ0jjEh8H9gAvl/QOSVVJbwNeSfra2Na/x0g9p3dIqhU3P70F+LszlFvxuoiIA6Sv+D8gqS7pJ/jBISSfIQ0deKOkTNKwpOskXbjGbespB1YzM7MuiYgngZOkoEpEzADPAP8aEXlEHAFuAG4HjgB3ADdExHSfqmxrKCIapDB5PTAN3APcEhH7zlDuTNfFO4DXAkeB3wc+3VF2EvhZ4LeBw6Qe199knWc+RUS/62BmZmZmtqJ1nbbNzNaSpP2SfqrL59glKST5plczsx+SA6uZmZmZlZoDq5mZmZmVmgOr2SpJOlmsVmODZbekbxbLIf59xx22z0q6XdL3JB2UdGu7gKQtkj4t6bCkA5J+pz2NTXGX7p9Jmpb0DGlCcJaV/URxzOckfVBS1uM2m5mV2kAE1mJt3uvW+JjvkfToWh7TBktEbCxWsrHB8lbStEOXAD8KvKd4fQewhTRx9y8Cd0saK/b9ZbHvpaT5NW8B2oH2l0l3+74auBL4+WXn+xTQJE0s/2rgp4FfWtsmmZmtbwMx6D8iXtXvOpjZwPhoREwBSHqAtFTiPmAJ+INiCcU9kk4Cl0v6Gmk98N0RMQvMSvow8C7gE6QA/BfFVDNI+mPSRPJIejFpucStETEPnJL058CvAB/vUXtL6Q2Vm7oyhc1DU/+55sd84/juVZ/zTGVXc8wyqux4St04breuk9NZbz/71VrttXk29rbuX/E6GYgeVrO1JOnWIqi0t5+SdH/H9qSk3cWd3pf1p5bWRSstlXikCKvL920jLXvYuYxi59KL46R5EDv3tV1clD0o6bik46Sgev5ZtsHMbKAMRGBtT0Uj6U5JnyvGks0WQwWu7HjfKyQ9XPxheELSjR37zpP0RUkzkr4KXLrsHFdI2ivpqKRvSXprD5tovTUBXC2pImkcqJPW/aYYs7oR+GYf62flMk3qfe1cRrFz6cWDfH+N7/a+tklgEdjWsYTiZn9rZGb2gwYisC5zI2nJs63AF4GPAUiqAQ8AXyb1XtwG3Cfp8qLc3cACcAHw3uJBUXYDsBf4bFH2ZuAeSa/sfnOs14pxqbOkr4KvAR4CpiRdQRqf+EhEtPpXQyuTiMiBzwEfkrRJ0sXA+0nLI1Lse5+kC4sxr7/VUfYg6f+kD0vaXHxIulTStT1uhplZqQ1iYH00IvYUf0TuBX6seP0qUs/YXRHRiIivkNZqfntxR+7PAb8XEaci4r+Av+k45g3A/oj4ZEQ0I+Jx4PPATb1qlPXcBGmc4TXF84dJYfXaYtus023AKdKSm4+SPtz+dbHvr0gfer4BfB34wrKyt5B68f8bOAb8A+mDs5mZFQbipqtllo8/Gy5WlBkHJpf1jLXHmW0n/SxON87stcX4srYqKRDbYJogrf98CfBHwHHgF0hDAz7Wv2pZN0XErmXbd3ZsXrjSeyPiGPDOFY7ZBH69eLTd3bH/BPCrxcPMzF7AIAbWlUwBOyVVOkLrRcCTwGHStDI7SXcDt/e1TQITEfGGXlXW+m4C+AjwfEQ8K2mG9AGlCjze15qZmZmdY86lwPoYqcf1jmLKmR8n9aC9JiJySV8A7pT0XmAX8G5gf1H2S8Bdkt5FGh8LaXzjyYj4n561wHomIp4spi16pNieKSZ9P1wMNzGzAXO6aXzOZiqjfkwPdDqrbefZTN9ldrYGcQzrC4qIBimgXk+6q/ce4JaIaPeo/hppjOsh0kTen+woO0uazPtmUk/tIeBPgKEeVd/6ICIuiIhbO7avjIjrO7YVEd/uT+3MzMzOHQPRw9oxluyflr2+H1DH9hOkm2Ze6BiHSTdXrXSOb7FsSUUzMzMz675zpofVzMzMzNangehhNbP1oXXoZT1fRrEf4xJXOw6wbPU5U9luLbdpZrace1jNzMzMrNTcw2pr4uKP/2lkJzOq87C4LWdoOqMx1iKbqzB8RORDsLAjp3asQm1WLG0KarOiOQqL25tkcxUqTUELmhuCGMnJTlTJx5agAsPfrZMPBQiWNudUZzOqc0I/MoO+vhmAxpYgqqkDr36sQlRh9GDQqonFrbC4rUXtRIVWPWhubDFyMCMEC+M5kQW1oxlDx8XcjhbKhQLqx8TCi1vUZlKdKw3RHGsyur9GPhwsbssZmarSHE3tmbusAYKhyTqNsRy2LhGnqqhRIeotss1L5CdqZKey77ftQGpbftECrbkqm/bVmL2sSW0mY2lLTn06o7E9p344I1sU+XCQDwdqikoTljYFMdSCFmx6usrsy5popEl9/zD5SNDclEO9Re35VOcYCgjYsi/j+KuaVGczaEFtViy8fIHs4BBP3/F+95yZmVlpOLDamqgsVsgaEJUUmpY2QKUh8tEWC1Sozgs2LbHUrIOgMd6gcmCI4SMQWUZje5McGJ6qAZBHRtQCzWdACsEjz2XkI4FGc5pAa6hCzNWpbgpCkC2IxtaALFjY3iJbEHM7RGNrC4L/C7P5UFDdPs9iY5RWPdj4TMb8+UFUU/2r8yIqEBlEFbJ5kdehelJEFWiKuUsbVKdroBTEhw9lNEeD7GiNqAWN83KiGlSO1ImhFsPTFeYvaJHP1qiNLTL0nQ20jtaZ29mkVQ+yhsinh1AtOLkrpzqTsTTWRAsZrRrQgsb5TYaer9LYscTo03WWtgRDx0Rz1wK0ROV7dZY2QvV4RrPWYmlzi2xeIMhGmjQ3VKmeEtUjFfKR4NSFAdUUXhE0NwbM1KiddFa1/uvWsIpuTDHVj3OanWscWG1NfOd9tzvl/H+8rd8VMDMzWz88htXMzMzMSs2B1czMzMxKzUMCzKxn+jEN0t5WuY57rtTHzGwtuYfVzMzMzErNgdXMzMzMSs2B1czMzMxKzWNYzcysdPoxd+nZLI3bDd2qTz+WDjY7W+5hNTMzM7NSc2A1MzMzs1JzYDUzMzOzUnNgNTMzM7NSc2A1MzMzs1JzYDUzMzOzUlNE9LsOZmZmZmYrcg+rmZmZmZWaA6uZmZmZlZoDq5mZmZmVmgOrmZmZmZWaA6uZmZmZlZoDq5mZmZmV2v8CzLD+eC0Eqh0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(0,10):\n",
    "    show_nn(blnn_set[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "target: 6 result: [None, None, None, None, None, None, 6, None, None, None]\n",
      "target: 1 result: [None, 1, None, None, None, None, None, None, None, None]\n",
      "target: 6 result: [None, None, None, None, None, None, 6, None, None, None]\n",
      "target: 3 result: [None, None, None, 3, None, None, None, None, None, None]\n",
      "target: 9 result: [None, None, None, None, None, None, None, None, None, 9]\n",
      "target: 0 result: [0, None, None, None, None, None, None, None, None, None]\n",
      "target: 7 result: [None, None, None, None, None, None, None, 7, None, None]\n",
      "target: 2 result: [None, None, 2, None, None, None, None, None, None, None]\n",
      "target: 2 result: [None, None, 2, None, None, None, None, None, None, None]\n",
      "target: 6 result: [None, None, None, None, None, None, 6, None, None, None]\n",
      "target: 8 result: [None, None, None, None, None, None, None, None, 8, None]\n",
      "target: 2 result: [0, None, 2, None, None, None, None, None, None, None]\n",
      "target: 8 result: [None, None, None, None, None, None, None, None, 8, None]\n",
      "target: 2 result: [None, None, 2, None, None, None, None, None, None, None]\n",
      "target: 7 result: [None, None, None, None, None, None, None, 7, None, None]\n",
      "target: 8 result: [None, None, None, None, None, None, None, None, 8, None]\n",
      "target: 5 result: [None, None, None, None, None, 5, None, None, None, None]\n",
      "target: 6 result: [None, None, None, None, None, None, 6, None, None, None]\n",
      "target: 1 result: [None, 1, None, None, None, None, None, None, None, None]\n",
      "target: 1 result: [None, 1, None, None, None, None, None, None, None, None]\n",
      "target: 9 result: [None, None, None, None, None, None, None, None, None, 9]\n",
      "target: 0 result: [0, None, None, None, None, None, None, None, None, None]\n",
      "target: 1 result: [None, 1, None, None, None, None, None, None, None, None]\n",
      "target: 4 result: [None, None, None, None, 4, None, None, None, None, None]\n",
      "target: 6 result: [None, None, None, None, None, None, 6, None, None, None]\n",
      "target: 2 result: [None, None, 2, None, None, None, None, None, None, None]\n",
      "target: 9 result: [None, None, None, None, None, None, None, None, None, 9]\n",
      "target: 7 result: [None, None, None, None, None, None, None, 7, None, None]\n",
      "target: 7 result: [None, None, None, None, None, None, None, 7, None, None]\n",
      "target: 8 result: [None, None, None, None, None, None, None, None, 8, None]\n",
      "target: 2 result: [None, None, 2, None, None, None, None, None, None, None]\n",
      "target: 1 result: [None, 1, None, None, None, None, None, None, None, None]\n",
      "target: 6 result: [None, None, None, None, None, None, 6, None, None, None]\n",
      "target: 1 result: [None, 1, None, None, None, None, None, None, None, None]\n",
      "target: 3 result: [None, None, None, 3, None, None, None, None, None, None]\n",
      "target: 7 result: [None, None, None, None, None, None, None, 7, None, None]\n",
      "target: 1 result: [None, 1, None, 3, None, None, None, None, None, None]\n",
      "target: 2 result: [None, None, 2, None, None, None, None, None, None, None]\n",
      "target: 2 result: [None, None, 2, None, None, None, None, None, None, None]\n",
      "target: 2 result: [None, None, 2, None, None, None, None, None, None, None]\n",
      "target: 2 result: [0, None, 2, None, None, None, None, None, None, None]\n",
      "target: 1 result: [None, 1, None, None, None, None, None, None, None, None]\n",
      "target: 9 result: [None, None, None, None, None, None, None, None, None, 9]\n",
      "target: 5 result: [None, None, None, None, None, 5, None, None, None, None]\n",
      "target: 7 result: [None, None, None, None, None, None, None, 7, None, None]\n",
      "target: 2 result: [None, None, 2, None, None, None, None, None, None, None]\n",
      "target: 5 result: [None, None, None, None, None, 5, None, None, None, None]\n",
      "target: 2 result: [None, None, 2, None, None, None, None, None, None, None]\n",
      "target: 8 result: [None, None, None, None, None, None, None, None, 8, None]\n",
      "target: 2 result: [None, None, 2, None, None, None, None, None, None, None]\n",
      "target: 0 result: [0, None, None, None, None, None, None, None, None, None]\n",
      "target: 7 result: [None, None, None, None, None, None, None, 7, None, None]\n",
      "target: 4 result: [None, None, None, None, 4, None, None, None, None, None]\n",
      "target: 7 result: [None, None, None, None, None, None, None, 7, None, None]\n",
      "target: 0 result: [0, None, None, None, None, None, None, None, None, None]\n",
      "target: 0 result: [0, None, None, None, None, None, None, None, None, None]\n",
      "target: 8 result: [None, None, None, None, None, None, None, None, 8, None]\n",
      "target: 9 result: [None, None, None, None, None, None, None, None, None, 9]\n",
      "target: 8 result: [None, None, None, None, None, None, None, None, 8, None]\n",
      "target: 0 result: [0, None, None, None, None, None, None, None, None, None]\n",
      "target: 0 result: [0, None, None, None, None, None, None, None, None, None]\n",
      "target: 0 result: [0, None, None, None, None, None, None, None, None, None]\n",
      "target: 6 result: [None, None, None, None, None, None, 6, None, None, None]\n",
      "target: 0 result: [0, None, None, None, None, None, None, None, None, None]\n",
      "64\n",
      "[6, 1, 6, 3, 9, 0, 7, 2, 2, 6, 8, 2, 8, 2, 7, 8, 5, 6, 1, 1, 9, 0, 1, 4, 6, 2, 9, 7, 7, 8, 2, 1, 6, 1, 3, 7, 1, 2, 2, 2, 2, 1, 9, 5, 7, 2, 5, 2, 8, 2, 0, 7, 4, 7, 0, 0, 8, 9, 8, 0, 0, 0, 6, 0]\n"
     ]
    }
   ],
   "source": [
    "right=0\n",
    "right_list=[]\n",
    "for i in verify_set:\n",
    "\n",
    "    inputs,targets,num=i\n",
    "    b=[verify(blnn,inputs,targets) for blnn in blnn_set]\n",
    "    res=[if_num(x,y) for x,y in zip(b,num_list)]\n",
    "    try:\n",
    "        ind=res.index(num)\n",
    "        right+=1\n",
    "        print('target:',num,'result:',res)\n",
    "        right_list.append(num)\n",
    "    except:\n",
    "        pass\n",
    "    \n",
    "print(right) \n",
    "print(right_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "m1=np.array([[0,0,0],\n",
    "             [1,1,1],\n",
    "             [0,0,0]])\n",
    "m2=np.array([[0,1,0],\n",
    "             [0,1,0],\n",
    "             [0,1,0]])\n",
    "m3=np.array([[1,0,0],\n",
    "             [0,1,0],\n",
    "             [0,0,1]])\n",
    "m4=np.array([[0,0,1],\n",
    "             [0,1,0],\n",
    "             [1,0,0]])\n",
    "m5=np.array([[1,0,1],\n",
    "             [0,1,0],\n",
    "             [1,0,1]])\n",
    "m6=np.array([[1,1,1],\n",
    "             [1,0,0],\n",
    "             [1,0,0]])\n",
    "m7=np.array([[1,1,1],\n",
    "             [0,0,1],\n",
    "             [0,0,1]])\n",
    "m8=np.array([[1,0,0],\n",
    "             [1,0,0],\n",
    "             [1,1,1]])\n",
    "m9=np.array([[0,0,1],\n",
    "             [0,0,1],\n",
    "             [1,1,1]])\n",
    "\n",
    "m10=np.array([[1,1,1],\n",
    "             [0,0,0],\n",
    "             [0,0,0]])\n",
    "\n",
    "m11=np.array([[0,1,1],\n",
    "             [1,0,0],\n",
    "             [0,0,0]])\n",
    "m12=np.array([[1,1,0],\n",
    "             [0,0,1],\n",
    "             [0,0,0]])\n",
    "m21=np.array([[0,0,0],\n",
    "             [1,0,0],\n",
    "             [0,1,1]])\n",
    "m22=np.array([[0,0,0],\n",
    "             [0,0,1],\n",
    "             [1,1,0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#temp=[m1,m2,m3,m4,m5,m6,m7,m8,m9]\n",
    "#temp=[m1,m2,m3,m4,m5]\n",
    "#temp=[m3,m3,m5]\n",
    "#temp=[m1,m2,m3,m4,m5,m11,m12,m21,m22]\n",
    "temp=[m1,m2,m5]\n",
    "mask_set=[]\n",
    "for i in temp:\n",
    "    mask=np.repeat((np.repeat(i,4,axis=0)),4,axis=1)\n",
    "    #show_nparray(mask)\n",
    "    mask_set.append(mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1],\n",
       "       [1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1],\n",
       "       [1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1],\n",
       "       [1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1],\n",
       "       [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],\n",
       "       [1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1],\n",
       "       [1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1],\n",
       "       [1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1],\n",
       "       [1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multi_convolution(oa,mask_set):\n",
    "    rz=len(mask_set)\n",
    "    rx,ry=oa.shape\n",
    "    mx,my=mask_set[0].shape\n",
    "    \n",
    "    rx=rx-mx+1\n",
    "    ry=ry-my+1\n",
    "    temp=np.ones((rz,rx,ry))>0  \n",
    "    n=0\n",
    "\n",
    "    for i in mask_set:\n",
    "        res=boolean.convolution(boolean.otimes_bv_bv,oa,i)\n",
    "        #show_nparray(res)\n",
    "        temp[n]=res\n",
    "        n=n+1  \n",
    "    return temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "root = \"trainingDigits16x\" #数据文件所在路径\\n\"\n",
    "pathlist = os.listdir(root) # 获取路径下所有数据文件\"\n",
    "\n",
    "random.shuffle(pathlist)\n",
    "train_set=[]\n",
    "\n",
    "for i in range (0,64):\n",
    "    filepath=root+'\\\\'+pathlist[i]\n",
    "    s=pathlist[i]\n",
    "    n=(re.split('_',s))[0]\n",
    "    targets=num_bool_dict[int(n)]\n",
    "\n",
    "    inputs=file2matrix(filepath).flatten().tolist()\n",
    "    #print(filepath)\n",
    "    train_set.append([inputs,targets,int(n)])\n",
    "\n",
    "random.shuffle(pathlist)\n",
    "verify_set=[]\n",
    "for i in range (0,64):\n",
    "    filepath=root+'\\\\'+pathlist[i]\n",
    "    s=pathlist[i]\n",
    "    n=(re.split('_',s))[0]\n",
    "    targets=num_bool_dict[int(n)]\n",
    "\n",
    "    inputs=file2matrix(filepath).flatten().tolist()\n",
    "    #print(filepath)\n",
    "    verify_set.append([inputs,targets,int(n)]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "blnn_set=[]\n",
    "\n",
    "for i in range(0,10):\n",
    "    blnntemp=boolean_net.booleannet('bl.db',75,16,4)\n",
    "    blnn_set.append(blnntemp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#multi convolution + neurol network\n",
    "random.shuffle(train_set)\n",
    "\n",
    "for i in train_set:   \n",
    "\n",
    "    inputs,targets,num=i\n",
    "    temp=np.array(inputs).reshape(16,16)\n",
    "    res=multi_convolution(temp,mask_set)\n",
    "    res=list(res.flatten())\n",
    "    #res=res+inputs\n",
    "    \n",
    "    train_id_blnn(blnn_set,num,res,targets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqwAAAA7CAYAAAC+PtjiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAqe0lEQVR4nO3dd3gVxfrA8e+ckt6B9AQCIQkEpAYSiqICcvWCKIgiAgqCNEWavaHIRaV3QYo0QZEiijSVHgIEpEOAECC0FEJ6OWV+f+whBELx5yUQufN5njzm7M7uzu5Z4WXKO0JKiaIoiqIoiqKUV7r7XQFFURRFURRFuR0VsCqKoiiKoijlmgpYFUVRFEVRlHJNBayKoiiKoihKuaYCVkVRFEVRFKVcUwGroiiKoiiKUq6pgFVRFEVRFOUfTAjxiRBiwf2uR1lSAauiKIqiKIpSrqmAVVH+JiFEjhCi6v2uh6IoiqI86FTAqih/k5TSRUqZeL/roShK+SSEeEUIsarE5+NCiB9KfD4rhKgrhGgihNglhMi0/bfJ/amxUhaEEDWEEBuFEFeEEIeEEO1s2+cKIaYIIX4RQmQLIeKEENVKHHfL90IIESKE2GQ7bj1Q8YZrRgshttuuuU8I0eIe3W6ZUQGroiiKopSNTUBzIYROCOEP2AExALbeGRfgDPALMBGoAIwFfhFCVLg/VVbuJiGEEVgFrAO8gdeBhUKIcFuRF4DhgCdwAvjcdpwXt38vFgHxaIHqZ0D3EtcMsB07AvAChgI/CiEqldmN3gMqYFWUG/w/WkWkECL0/tRSUZTyztYDkw3UBR4G1gLnhRARwCPAFuAp4LiUcr6U0iyl/A44CrS9P7VW7rJotH+YjJJSFkkpfwd+Bjrb9i+XUu6UUpqBhWjvCtzmvRBCBANRwIdSykIp5Wa0oPiql4DVUsrVUkqrlHI9sBt4sozvtUypgFVRSvsrrSL772P9FEX559gEtEALWDcBG9GC1Udsn/2B0zcccxoIuGc1VMqSP3BWSmktsa3k93uxxPY8tL9frh53q/fCH8iQUubesO+qysBztuEAV4QQV4BmgN9/cyP3mwpYFeUGf6VV5IY/fBRFUW7lasDa3Pb7Jq4PWM+jBRglBQPn7l0VlTJ0HggSQpSMt/7K93u79+IC4CmEcL5h31VngflSSo8SP85SylF/7xbKBxWwKsrN3alVRFEU5a/YBDwKOEopk9GGAbRBG5e4F1gNhAkhXhRCGIQQzwM10bqNlX++OLSW07eEEEbb5Ke2wOI7HHfL90JKeRqti3+4EMJOCNGM64eQLEAbOvCEEEIvhHAQQrQQQgTe5Xu7p1TAqig3d6dWEUVRlDuSUiYAOWiBKlLKLCAR2CaltEgp04F/A0OAdOAt4N9SyrT7VGXlLpJSFqEFk/8C0oCpQDcp5dE7HHen9+JFoDFwGfgYmFfi2LPA08B7QCpai+sw/uExn5BS3u86KEq5I4QIQ5uBeUlKGSqEcAOSAAPgKaW0CCEkUF1KeeI+VlVRFEVRHnj/6GhbUcrKnVpF7mfdlLIjhEgSQrQs42tUsWWYMJTldRRFUR4k6g9MRbkFKaXfDZ8b3vBZ3NsaKYqiKMr/JtXCqiiKoiiKopRrD0TAalvqrMVdPufLQoitd/OciqL8I9QVQuy3LYe4pMQM22QhxBAhRIoQ4oIQ4pWrBwgh3IUQ84QQqUKI00KID66msbHN0h0thEgTQiSiJQTnhmNn2c55TggxQgihv8f3rCiKUq49EEMCpJSR97sOiqI8MDqhpR0qALYBL6OtMOMLuKMl7m4FLBVCrJBSZgCTbPuqoqUrWoeWK3EW0Atttm89IBf48YbrzQVSgFDAGS2d0Vng6zK6P0VRlH+cByJgVRRFuYsmSinPA9iW6K2LFrCagE9tSyiuFkLkAOFCiF1o64HXlVJmA9lCiDFAV7SAtRMw3pZqBiHEf9BSpiGE8EFbLtFDSpkP5AohxgG9+R8PWK0Xq/+tFDZP+Ne9yzXRrD3/Z5lcs6zO+3f9N/W53bE63+NlMua/le65e57q6Hb3WVbux7twP6y3/nDL9+RBGRKQJIRoKYT4RAjxva1rLts2VKBhiXI1hBAbbUuVHRJCtCuxr4IQ4ichRJYQYidQ7YZrRAgh1gshLgshjgkhOt3DW1QU5d651VKJ6bZg9cZ9FQEj1y+NWHLpRX+0FtOS+66qbDv2QoklFL8GvP/Le1AURXmgPIgtrO2AZ4FXgBHAZCBaCGEEVgGzgdZo6+quFEI0lFIeA6agdQH6ASFoy3GeArAtf7Ye+Agt+W9tYL0Q4qCU8vA9vLdy62atISZp4V8v9SLPx47tY6fTZFAfnFKK+HXBTKK+eB2fiduLyxr8fPl8+0qe+a0/Ya/uBiClfxN2vzeZVt17UeRhYOtErcFpRFoEW+u7cGZxBCPrrGBGg/pYsrJuXTkhqLVbkFrkwqWYLKy/BdHa5zC/1fVEmq/FH8cnNiaxo3aNqht6UL3bHgDSX41h96fTAOh5phnJ0TmlLqEPDWH67/MJNriU2gfQ4mB77FsnEbjDhVnB2tDohh/1pcI3sdq159VnbrPZjGrcCktqavFx54c24cDgqaXO9+aFhhxpaIESeZQT5jTg1BOztPovf42Id4/QJ3437ZzzKJQm/v1ib3Sb9haXN7VswPpvZ9Jw5AC8p2jfRcI3DTn15Ddl1hrygEpDa32tDFz986Dk0osXgKAS5W9cQrEQqHhDMKwoiqKU8CAGrFullKsBhBDzgTdt26PRWkNG2daB/10I8TPQWQjxGdABqC2lzAUOCiG+RVuWE7TxZ0lSyjm2z3uFED8CzwHD78VN/RO8d+khvotvdG2DFBhbG5CV8wFIfboAcdqRsNV9qHqoEH3FCiT1DcdveyGGw9rf7S1qHWPHR00ImXYcAL3QcaqzQO9QpO0/2J7TJ72x/0jP09ViqW5M5cS7keiKBPpCCJ50AFOD6px72IGQr09gDfImqZ0rCXEWnJINBLKdi78G8Y1HIFWsO8npFE16pNbRUL9eApnWfBps7gsZdpz5uAlVvz5ZfDtRezqRG1uRILaT0T2GrKpaTBe8Lg+OnaXFqiG0i45nuM8WGm7uS4PKZ5hfZT11d3RDv80dP5KIXfUQISERABjCwDSoCb4T4vDaZE/3/F7YvWHAL7YKDr/t59zABjg+kopFWqkT15VKrjn8EbmS6D87cinJC/vheqqszEKXnMqpPqG0rLmPFEsuMRsHIIoEJ96NpLpxDeMzajJhWytqnEvjagLZ9FdjyKoGoatfo9rhgjJ7J/4X2BaR+B74XAjRDfACBgOjbUW+B96w/XmTC7xT4tgLQoh1wBghxIdouX9DgEAppVpRTVEUxeZBDFhv7M5zsCXo9gfO2oLVq65221VCexa367ZrbOuuu8oAzL+L9f5Hy7Tms3hbDGED4rQNOj06ZydqbcrhY+9YwIHjLeYyPLUmO5pVAJMJa61QNvf+iibOQ6meaA/AnOAtpPVaQ9eVryKskkxrPifazLBdo5D8BX6EnC/i12+nYJESE5DQXWv9PFKUx5AfXiL5MXvieozhufV9SGnozKGek3msTx+c1u8BBwf8x8aBVQvdLj1dSPwjU3HXOVIoTewrMhD+3mWSOgfya98veXV9f6QOMix5OE9xx2tNLDoHB4ydLxFXayEATQqGEByfS/iQfaz6T0Nebr+N6iPyOPB0BJf6/oT/OCOG3dq1K4/Zg5QSWVhI2qowujy5mw1zK1Nhzk58fg9k3MZFtPEaTI29nozpPZNHHQtIseTj/5WBzOr+MAqMMytQJd/KhllTaHhpAN7xelb3+BIvvZ7YAi8iPkgjoV8gu7qOxV3nRIfdzQjrvYuSqx34dz1FtFMGxxsVIQxGhIODtkMKMq35eJb1C/PgeR1t4lUiWk/NTLTeHGy/hwH7gCy0QPaxEsd2A0ahtc662s7xxT2ptaIoyj/Egxiw3sp5IEgIoSsRtAYDCWhr7ZrRuu2Olth31Vlgk5Sy1b2q7D/N8+17UePSOa72aWZ0a0T3t35m/udPEeMfw4FBWrf2G1678dsZCoCb7hieOkcWPD+Ro+39qGF3/ZBq3x8S6BTfmydmbyOpoAIJfcIp+OAKb9X8BXthpPr8vvjutLJ8wlgq6p0JNdrzwqrNhNldwkXY8+q3K6igz0EvdAwau4gUsxsA899vi9MyLbAO/+AybesMZOmkcTTe8AbhEwsg+RiVZxfw6sb+eI0+y9nzAXR+pjeOx45S9Fh9npu0hmkz6vP8B70AyOtfyDN7zwDwxZq6DH2lLzXnHeDIfjd6duqH5+iztKxwpvi+piU8jPfTR/EZZGJZ3VZ03LqWb6c+if9qrZV52ZMT+fPxIJo55PLw/s64f+iI/uAxqF6v1HMfPfhr5lxqzmud+6MrslBYwYGmK+M4ssWfjl368f7sb2/6fZl7u5CodwOZwLHJdXj34V+08y2vx/Pte7Fu5//7FXggSCmr3PD5kxIfA29V1pYp4KVbnNMMDLL9XDWlxP5MoK/tR1EURbmJ/6WANQ6txfUt2wzepkBbIMrWpbcM+EQI0QOoAnRHWzsetDQzo4QQXYHFtm11gRwp5ZF7dgflmNx9EEu9SDIeD6LiskM4XLGw6EwUngeuoLN4FJfz1DvR2/08ABfMObQ+8iImix5Hg4mnw39gSbYfk050wjszF3NaOqRfZtLWluicTXg95ED7kM10cNHGq1r8CskOdODfB7rTK2QrPd0v0s0tjYXZ3rx7shnzwxcSaBtTuiytPklZFQBIj9RT4BFTXCeTs+Df+19Gf9lIej07qBcFgNUAQ322MDy7LXJ3IhIw5JpYcKYxFQ4XIXcfBEBvX7f4nmZWv0x6rYq8VnEzq+1rIXYfZtfxOvg7ZjLebzc9zzQjO9cBfc8YvDddxCUpl1fdjzK1+cOcJ4AuB17B0WjCqLfw7/DvqOyWwcna3lRKcr7pc1+T+RB7LwTgGOmEsEChh6CPVyyLdE0w7j1JltWhuGxuh8YY8q3Yr96F5diJ4u0evtnF9R8flk36Q65/+z1QFEVRlLLwPxOwSimLhBBtganAu2gTIrpJKa+2qA4A5qANKThq+/1R27HZQojWwFjbjw6te2/wPb2Jci7xOTe2dh3Ny7t64LhiJ6wAKyAjo29afktBAHbPZGDIzsbg58uJ7Xo+3tqesFd3F7fUIiVhfXaS27ExWydOu/56rWazookLMxrUZ8SodvRsrw0d+GB7eyL6H2HDnqq87JaCRVo5+0kYjmu1yVwBv5lZX2NV8XnW5NkzsWE0aZ96sWvE9FL1vG6Q8o79OLcBrde2tF31v4f6AI5a9c1mwl6JZ9srMfD5bo7/pyaBZsnGmdNo+FFfKv6ZDUDCw/PY3IjiSVd6D3d27/ZiccjvFI5YS9tjr167iICri8L+/nU0QTuzWLJqLO46R1uB0hO/hMFAm483sT29KpbV1++zllhh9nCTBdAE1Kut/FPdKeXQ7dID3Y8UU2VVn7K4l//m2a633nKXovwlD0TAWqJrbsMN25MAUeLzIeCRW5wjFW1y1a2ucYwbVqhRrvGJdeP4bisdBwzCOemQtlEIEhfW4dXavxWXm5vlzTfvP4P3wERmhKxg7fra7J0bg/eseIYM6I+huQHnzZUo6OFCVl1vggclcHlgAO5bk2je/7VS1y3w0BH08wn0cfri/cZGOnx/1/Ok8ym0POwa6yP18PnPKYb6LQXsi7c3ts8gYK2ZhK2Cxm/3ZeZn43jI7lrL5LjwJUzc3oqUoZWROoHPl0mcHRmGw8+l+80jY7vgutyV6Z9N0B6BwcCZxRG8GrEWgMc/vbZ42kuDfmXJmQa0eXMgwgJFLjp8lp4ieWUT/MbHMer1bvRtD6fazqTelH38eKQuzQe8RvqLuRgMFlq83hffXWexXsmk7YCBSCEo8NTx4ydfAWDJyWXsG12QjY14bXJl2bQoTK6CerE5nH8vFP0fWhYE35EGmgdoz87UK50ddZf+1a9dURRFUe6JByIPq3L/+dhn43BJj+NPuzDXD8PUuiFFrRvg7ZVFmsmFYRfrcdKUw6nCSjgv382+3dX4IrUZXna5ZFcBc7NaOKzbh75QMCNkBdLZgVwfPfOr/EaRhz3SbMaYa8F1ayJOy+NwWh6Hy/FMhBVmhKzA6lOIMdeCMdcCEvzsMzFyfWamAi87FlTZyJ+FQYy9XBWA73PcGZnaFA9jHk7ndVRYc4Irtm50i7Ty1eVqHC30Y0GVjRR52iENOvwcMrlcw4BsWrf43DnWAj5IqU3BGVfssq2MSH4K3RntPM4ORVwocmfYxXp089jJx5W0zEde+hxc7Iow5Fox5lrQWSRTQ5ZSFJ2NqWU9dBaJMGn/i37h8yePVjuOMceC0WDB3mDBmGMBsxksFozZFtz2XsD7t2Ryrdf+tzbmmCn0tDKnyjoqHC7A+ZyVeZU3c76JAzKmDgC6QnPxs7t02othF0uPlVUURVGU++mBaGFV7r/9DSCIWHQuLvSctYwOzhkUSjNtu/Vl/x+nAHh7c3si3S4AEDokjv22Y83TLIyePY33mz1zy/NntQhl04RpNH2rH+4LtTylpz4ycqjpFPTCmcSWs7E8rvU5ha7tzd5mrqyMr8LLbimlzjX1Px1wTyyg/+JjfPZNF/y/0nKh+sntUKlScbl8WcSGHk1Ir+NCt+HacAT9xj3sbyDwXHOBNt33sa5eRQB2Fzqxp6U3vA/fTBzHmy27EnJiB1JKvNoe1+5V6BgZ+wQzg7YBMHHMc1TYl8PyHyfgptOCW71w4Wiz+Vialuw/0wLQmUHbMM3ZzGOv90Ofb+XXOVNpMvwNKu3KYsnciTw8Yxgh864lutC7ONN39g+0dcrixgSfB/pN5p0ODdjfQHBuOOyN0oZTRM7qz/4GcF1KAUVRFEW5z1TAqtwdJRLY65HohQ4nYYfh/UskPRpNlQ9jsUpBB/d4flzak4rfOOG8/zzHv6qI/pyOrlMHUTgmB3OKhZZfDsM/+Si+myT1DQMIPJJEUUwQeqEFbvoa1Tn1qQPWky5EHu1PXI+xPLG/K9lbvPm5z5cgJFi0iGvIhfpsmBdN4KHTYDRQ58t+BMRewlzJNrHICgYfbxLG+uG51hGvxXsY9EVfitpkEhs1G2GVeG9Lp86X/cjqWIhTj0gAzDvdWHzSF0/zDoLmGRmy8TUqZcZTdVkhHZOHkT88Dzv7msXPxLrPneBPt2OVgrlZ3oyb3pGAbWmQks6jXw0l4vmjfBq4imemD8PzkYusilxAk1lDITKbI0217Gkj0iL4YfZjBO49B2YLjb4cSFZ9M84d8nDXOVBiKCp9H9nArG+a8MGsWnxcAEgIPHYSAkMACF3VB8dkA2JpJqbDbtQ81J/47uN4tu02VkbWLqu35G8vo1hWSyH+05a+LItr3sntxyXeehlFRVGUu0kNCVDuCn2N6uh9Sq8m+X7Iz3g2SEVfozqX8lxJMnkxsvZycvwMSGdH3q67Fp1J4Lc1l161tiHtJP7rUrBm5SDOnCdgTQrW9MvF58v31pFV04sRdVbimghV519iSXY1srd6U3nmMeZdaQRmHURUxUlXyOYLofhO2I45+RzmU6fxHb8dS8JJdEUWVuZWxJgrkW4u/NFsMqlNzeiqBuOzOY38k27F15RnLxCwNpXwyheZVW8eh2IW4pYInnNjQUqc/jyDz5Y0dKGVMabl4Lcth7nRszkUs7D4J/zxk+hrVOdMrieLz0cRsDYVefYC1sxs/NemEHe0Kt9nNiDwt2wuHvRmWU5V/DcXYjmuTaDaXAALjkbhO347WK2g1+E7YTuVgjJYE7mEdfnOGEsswDXM6ySbY6ZT6U8TgUsStWdw8VLx/oANAt8dheyPno/zOUG1hekszQmml9d2DsUsLIM3RFEURVH+PhWwKnfFjLVzOPp+yHXbTNLCR6/3Qn5XiRlr52BZ4M30qCimR0VRcV48loST/BgTjsnTwuD5i/mjQz3sUvWMXLMQEV6VS50jmbJuLqaYay2Vvw3+isbv7WJWkygqzYnHcuIUK2KqEzQmHktaOnHNK+JwzsjMn2bQwTnjlvWV8YeZ26gu3t/EF2878OQkZqydw4y1c4h/YVzx9vQOtZi+dg65kwMZ/G7/Uuc6Miqw+LgZa+cw9/upRNtfX2ZJ6M9MXzuHvOn+5E4OZPraOaR3qAW1qjNm7Twck+zY9mJd3v1uIVYjLGsTRdepq4jrOoZCaeKTPq8S8oqWmUB8a8ZzURYIrXFrea4fU5s9gv+U+Ouu6a13ZtGMcRwb7XeHbw8sR47zfXQNHt/4xh3LKoqiKMq9dtshATftvtPpid5bwPBK2kzwkuvDG4W+uFj4nL6ETj5VvD58xMAjvLTnKKOPtsL76aPXnVL/hz+rw7VcO3W+6kfA2jRmrZmNn8GFI0V5DG3eicRXgjnSp/Sa6jdTe2w//EdfW6deX6kS78St5+FrE79puv9ZXNokUm2XA1MDdtz2fNWW9CF8RAJDdm7itR3dCH35EE/9eYnXPbXFsB7u2xudWbJx5sxSx24uoNT68DfjE+vGvMqbAWgwvC8Vv44t3meoHMToTUt46pdBVO8fV7xdGAw025OjpSp69Px150tZGcHeKC1lbMTMflT+eHuZdt8FGlyQdqVfF0OeBb2rnkCDC/kdMzkdFEngqFjSe0STGySo/LmWasrfkInIyUNYBYEGM+gFFQ7k0WrpUGQ77Vyh3/UBbCmdPoCQFUXYHTpLwluhBGyy4PDzTixZWWClOP9ql5CdTBrXhvBpqVgStGVWU/o3ocgdAv8TS0a3aFIfNuGhM9D79L/YuSNcu1a9s6wK/4njA42QJnnsh6GEHUoDnSD0uz6EHsjm6t3q7CzF1+t2+mG2b9cC7Gp1k/k5YiXhG3rh6ZVDfIPvufJCDlarjmCDC7pOqRx/3JVQoz1YQSRfoPeS1wjYZUVmZuFryGT85SgWbmiOfBJ40tZVv8d24XHwZpVfqW1/jiPvd6TyL1YcdyTw9KIhWO2vfRde+wUIQfI7MdjHpJf6jlzbXeBMxRgqj9yN72o7QtP6kDioVDFFUW6hrIZc/N2UV3dSVsNSymrojqLAHQLWvxLg7Pju6m/vXrf9+LtXN03idA+gh7a9a3W05JylaGmADowBxgB8DkAk8GvxIql/7W/RQ18CX96+bKzvrepR2qmBwEDt98QQoPP1+7cuv/rbW6WObQG0uFRq823tnQZMu3HrWJJutxbOTe/lMwASPgQ+LNsI5Iw5ByToPNy5aHbnjPk8BVJgdtRjctJeo32NvmNk1XC2fhNMbpsc+tXczJpZtcHOih6JdHdB6iSnzUYsznYYjpwh7D86glbncS7PA2uHQqyZWVia1ubnRTNodHogASmebHn+K5rphxK+zRPLlSvFdUo25/CS2yFe75RIyzW9sU80oHN1JeC5U7SsdIR1s8LIeCKfLc0m46JzYUd8GBEjjgFwcnAExgg9Wx+ZRLv9PajUVfsHhzSbqTbkOMLZGZ2ntoCp0WjBIq2cs+QRuymSau/Eovdw59SbkZjCLYTME1ypVoEzdXL4NeprHIQAnPm59rfkSckFC8V9HSHv2f6h4uEOwI8n6xL2ZSJ111zkzYqxeOudiR7WB2OeZO74Mfjp7bAXdmx8egz/Ov8WgWsyr53DRhjt0FWsSKuOO3nPexMlU30BLKu5gFn+ddn4VSVcl+zAdQl/9X81RVEURbkn1KQr5a7o07I7xh56XtwQy6z+7fnlTCMQAt/ZJxnmvwawA+ANr300jE1kyIxeLP+6JT03rKC542kC9E68tWopr2zoyQdPd6P2nAO0cj+EBcHI916myFnwWdxsRrz9Mo5pRaWuv67DaFY/Ecma1tqkqExrPl36DyattoH9/ScDUNCqHu9MmkdD+8s4CSM1t51j0OxedJs9kIWzJ7D+6TEcf1JbDauy4RfyrAaef2MwpmADb+xaCcBnJ57CpU02ibOrMaHBEgBq2aWzo9CJzzr1oXpSAnh6Uv+PNMZ4jMZJ58SnM2cy4MCL9GnZHYDUZt7sGjGNFpOHEbxc+9dM/ttFNN6UStxjvlhKjNld3/Br4rb6Mnboi/xcrRn7h05lyoiJDD/TjtdbdccyrZCeQVuY8+yLVD535KaT+1N7NODjod/y1dtdaRXUiH1vX99T8fDXwwhZeA5r3umbHK0oiqIo958KWJW7IrmtD1aDleF7n8IYZY++jg9SQE6CO13O9SxV3veACcejF/l4dzsMxmtJlzz3GpBHElkW15BfKkYipaDaoQwszna8uacTsq4OfZEjD23tifSRnOxSASedHj+dIx1dDzH11adwbKB1ezsm5+JT6EjNrS9T9UIOOdXcaeNUyNUWxtZOJnRF4HgwmWabX8doZ8bOzsyGBt/wQ3YEE/Y9RvV9l8ir6G87Ds5V3s6EIc/yYsRGKhsy6LC7N1aroDDTgYjDh7Dk5aFzdmbhrmiu1HVign8sbyd0pHCXF5aE7WR2iSYnWBCxtSsBuwqLhykIY30edT1MnC4AAFlkou/v3fhXvQOM89/C1NRCHN21ITcN7O2o6pLGkeOXyCgIJcCQwdmnvNCZvYqfY6W9hRg37yO1ZxTZITA0viOhh9IxOVYsLuNwIYeaW19GOkvOPhsABOC7PRcRu+/uvRiKoiiKcheogFW5K+IHTyJsVV/C+pym96542jvnkGctom23vhg2Hr5WUFq1FFhCYBY6qnU5p00esqWsQlqRUhLWz7aKlE6vtRpKK5U7SfR/+NOkQiJb67uQtKgGB5rOBewwSQsV9Y4ceW0qFmkl3WoFvcC4Pp4q6yRWIZDVG5WuuA7MKWmEdksDaUVfwYsDcW6M2dma6i/HY9bpkTr/4uI93S/SbfAkAMZn1Ca4cwLSbAKh00ZlCIE1N5ew1/bwx9uNyer3B84fOeO8UxtTHfn6Qez1Zk5GFdz0OQq9DnR6rAWFhPXexZahTSh48w+kTiCFNpENwGzVczVZalMHHXvfmIQOgV7oMEkL4cv7EbHbiY+Hfsu7+58h8LmjWKwWaKgFrFInsBw5QZXOkLoilD0NtdbicI++VInT37Rud0N5S4NU3paLLG/1gfJZJ0VR/veogFW5K9p07Y3hCT2NN6XyqGMqTx7rQMHnfpjfvkzM2Gtd+D8l1cLvmaOcGNeYKrXOY9cujaShdenw7BYAlq5sTuWPteAuq3M0j7+tJdn/7mBDQl/ae901qw4voo1P7+LPRR4Gpo8dT7cD3XGb7IbjV+c5ergR1fvHcfaHSIZErixV7896zWP3i1p2g5ULmhMwfiejunclIjUTq9GO7FWBDAtZXFx+eGpNNg+OAQn6fDPCtI/EL2J4/gltydUV3zUneNpBDKucyEsw8Vy3ARgPHftLw6Ub2hURs+40BVYjlwrdON/Ji+DFp3lm/+uIT1LIznCnTVftfo3ZRSAPAPBLngOjB3Qlq38m82p/S5/BbxJx4Nokv4X1Z7NwdzQHekUWb+sxfAWn3tMWSejk8S2gzUic0Hk2W9uG/YXaKoqiKMq9owJW5a4o9DIggvNsy446cvaKB/6/7eHMK3U54aIFRu8FrCY04hIzn3sWq5uZArOB/HYPUeht4USuVkZfouGxwEvHCG8tKDsRUokM4OihIC4EueH0rAfCKjHkW7H/dQ9YLdh7etL7aBcuJ3tg76EjP98Jfa4OhOBfIYeJdjzFC6eeYpj/Girpi3jnbFusJZZvzfezktO+ga0e2jCFjBwnVqTVY0WaVibuSFXCftMyG+g93Mnq0Bizh7m4/vm+VtLbR/J18Hg6JvdB/8derIAhKJAr0QFEuGzgVP611bSucjjuwMDwR5kcuBF7YSTNkkvrJ4filGrFqhcMCd7IJo9w9njVx31rEtJiJatjYyIrHMaIhQJPPZeTPXjV8BKefyRgychA5+TEJ0fa8kq1HYz02U29ljEUemnZA3q6XwQuAjA+I4KR56r+1++AoiiKopQVFbAqd8XWiV+X3igl1brs5Wo21E82t2VZ6HpeHj+duqP64TbWjm9/HUPzeUPJaKpNNApke+nzlFB9QBzWR+rx86JJ2AsjK3JdmLGlPpasLCwZGbi0ycDhI19+GT2azu164b43tjhf6RcXniCj6WXe+a0DrX0Oc7lFLtJ0rfXXOlEW30fVDT2o3q2IoI4HKZnNNYxrE6LMNaqwbsIkGk1+k4zXbNvHQdyoacD1iVhTWgax63Mt9UO/c6UD1qDPtnN+QWVObywizGikot6ZPR9enyqig8sumLiL5v1fw5BvZdOEacWrf7UeM50a0/vh1vdk8cQra14eldodY+bgp3h96FQODrx5Wrhvpz6J95QbnrvqBlYURVHKERWwKndFo/e0fFsWO5jyjjYrHyFImNmAKpW17unPgpYCxuJjxJnztH1vKFUPZCI8PUme40sF57zi/e28NxX/Psx/DW9t6IhVCoJcTmIvjFRd1xP3XfY4f38Ro96TK3mO+PXUruWis8dj8gX2/hFDlQ9vkWdXXh+Vhc3Po97Rfix6a7RWP4OB43Nqo092IOTdWBKmNqJK9Ws5ylKyzDzy4UCC49IQfr6kzHSD41D/s77MfXscX0T9yLg1LXEbqMN74/niZ5TvLai4/hwAZy56Uf2VAyQPaYR9szReHDEUnen2z/ryc/k8Wu14cbB6Va9Oa1jVXMvVmvFTAH6z/iRxTihFV0xEfdCXYe8sYn9eMOvGNwMgsxoc7jHl9hdTlPvkfiybW1Z5T8viXu50TpUTVXnQqIBVuSs8j+ZiuJCBNTWdsd1ak5drj4x5iMEx64sXWPgp151JeVrroskZZNVAPBbswColBj9f5tWZi05INuWGF593ypUgnnc9io9e0t5Pm71eyZAFgD7FDqcUCysi53PC5MDyzAbsbBhFoY8Fo9CzOOR3ojKuzYr3sc/mUvRD+Dkl4aXPxdq4OYYT57FcSgFA7jqAX1IlUoc64eGRiyW6Fv9pvIwJlR4H4F9R+69bZGJeVkUWjP03pF8BOztaBRxl5fZm+H53iHHdW1Hf9QxPB+7jd4dGWI6dwPOU9hycnorijze18bTfV3ZnZvQz2DVNZ0atBQyb1A/HIxcxn03W7tHHG0tlH3QHT2LN04L5iNfc+Nx/HVOuRGCV14JWo7DwUmAc3dzOEZ7QDz8hqBeYzM6U6njN3cnETo+TVWCP39FcAITVmUlXqmJyBaIfugtvgaIoiqKUDRWwKnfFj0tn8NDKgVTvf5asxy249HVk2fdjcRR2XM2KP/KTbngstU2cWpRJx26/s7RhNay5ucXnefr3AYT3PVD8Wej1XNjuQWJuRTIez0dKialZS56ZN52DXSZietGCi86ZmO/6EjbpLB9snE0zhwJKtuReNconnvylsbY6wfNLptNk7GD8xqaUKhvXYBGFi0246BxsS1qU1sU1hWeXTCdmwmD8v9rOnmhHAk1xWKwWLjxizy/4AiALj9zyuXVyyeTJxdOxF0aMwo6fZk+mzg9vEjpIC1iTu4SyYdBXvNSp33Xppr5Iac7h5g5Iy/WZV3XBATRZvwAAa24uVx4zE2aJR1otuLRNxtS5AT8u1Zad/eBSM9ZG+aNblMGPA+bcULMPb1lnRVEURbnXVMCq3BVRMwajc7eSMEebtCRyLETNGAyAKTyfE4/OwaH7RY61rAXA2zXW4KrPB52OjO4xpDY38cK8QehdrByb9BA1Pz2POfkcUghMUk8Xn1gGTOtC2NcmdGatKz96d1cK4rXco8HbCpFFRbjqCrAXRgqliRrLBqDP05E225VTa+1YHlCXxFazCdvUHf0RLRdrYRULJ8ZHE/bOn1gLrs346pf8MFvW1GFu10m8VmUzH895mlPr7ajqH0li61mEb+mG7pC2HGvQNi3gloWFZHWO5mJrrU/fK9aOit/sJHFUDA5poni5YOcjqdSY3k+7vreFI89M5uH9nUg96M2OF0Yj9deWVfWNzaWF8zBCziRxLVstWNBhzc/n4psx5PlJqr23C2k2I4q0a7/QJJbv5kSV+p6qBp3DRedAtd9ewX2bA5XyYnFZ7E7UnsHXlTv2yf/n21cURVGUsqUCVuWuCP50O6dGxnDiiVkA1I57Ef/Xtfyr2S9Ew6OwsdYKqHXtmO9ztOVHU2MsrGw5mXebPsvJ3lXY0WkMXae8Csnniss+5VTAU0/MInpDH1yTtST+1o1eBI8rMVnIx7v41wJpJmx2DimN3dj10kxa9uiN2ckIrcDzVyc85mnHJS15iAkNljDxk2goEbD+diycsJHx7O8URG/383R7YhYtevXCatBDa3Bb44zXnNITxFIawSnbMwi1e4VKc/S80XY1P56rB9rQWMyJSQR/mgSAaFgLU3sLmVt9CF90jsudrj+fiN1HUCzXBasl2bdMZVC1TSz5qCrSfK3USJ/9jHxi/y2OAr+Vdjgv1ZZwdV28A9cbC3yi1mZVFEVRyg8hpbxzKUVRFEW5h1rpnitXfzmVt0lXd/J36/vf1PV219T5Hi+TRUPux3tyPya03Y936H643eIyulvtUBRFURRFUZTyQLWwKoqiKIqiKOWaamFVFEVRFEVRyjUVsCqKoiiKoijlmgpYFUVRFEVRlHJNBayKoiiKoihKuaYCVkVRFEVRFKVcUwGroiiKoiiKUq79HzhG/lSXBMbZAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(0,10):\n",
    "    show_nn(blnn_set[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "target: 4 result: [None, None, None, None, 4, 5, None, None, None, None]\n",
      "target: 4 result: [None, None, None, None, 4, 5, None, None, None, None]\n",
      "target: 1 result: [None, 1, None, 3, None, None, None, None, None, 9]\n",
      "target: 1 result: [None, 1, None, None, None, None, None, None, None, 9]\n",
      "target: 7 result: [None, None, None, None, None, None, None, 7, None, None]\n",
      "target: 0 result: [0, None, None, None, None, None, 6, None, 8, None]\n",
      "target: 1 result: [None, 1, None, None, None, None, None, None, None, 9]\n",
      "target: 1 result: [None, 1, None, None, None, None, None, None, None, None]\n",
      "target: 7 result: [None, None, None, None, None, None, None, 7, None, None]\n",
      "target: 4 result: [None, None, None, None, 4, 5, None, None, None, None]\n",
      "target: 1 result: [None, 1, None, None, None, None, None, None, None, None]\n",
      "target: 0 result: [0, None, None, None, None, None, None, None, None, None]\n",
      "target: 4 result: [None, None, None, None, 4, None, 6, None, None, None]\n",
      "target: 7 result: [None, None, None, None, None, None, None, 7, None, None]\n",
      "target: 9 result: [None, None, None, None, None, None, None, None, None, 9]\n",
      "target: 4 result: [None, None, None, None, 4, 5, 6, None, None, None]\n",
      "target: 6 result: [None, None, None, None, None, None, 6, None, None, None]\n",
      "target: 0 result: [0, None, 2, None, None, None, None, None, None, 9]\n",
      "18\n",
      "[4, 4, 1, 1, 7, 0, 1, 1, 7, 4, 1, 0, 4, 7, 9, 4, 6, 0]\n"
     ]
    }
   ],
   "source": [
    "#test\n",
    "right=0\n",
    "right_list=[]\n",
    "\n",
    "for i in verify_set:\n",
    "    \n",
    "    inputs,targets,num=i\n",
    "    temp=np.array(inputs).reshape(16,16)\n",
    "    res_inputs=multi_convolution(temp,mask_set)\n",
    "    res_inputs=list(res_inputs.flatten())\n",
    "    #res_inputs=res_inputs+inputs\n",
    "    b=[verify(blnn,res_inputs,targets) for blnn in blnn_set]\n",
    "    res=[if_num(x,y) for x,y in zip(b,num_list)]\n",
    "    try:\n",
    "        ind=res.index(num)\n",
    "        right+=1\n",
    "        print('target:',num,'result:',res)\n",
    "        right_list.append(num)\n",
    "    except:\n",
    "        pass\n",
    "    \n",
    "print(right) \n",
    "print(right_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(verify_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "bl1=boolean_net.booleannet('bl.db',3,3,3)\n",
    "bl1_mirr=boolean_net.booleannet('bl.db',3,3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs=[True,False,False]\n",
    "targets=[False,False,True]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs_flip=[not(x) for x in inputs]\n",
    "targets_flip=[not(x) for x in targets]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_nn(bl1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "bl1.train(inputs,targets)\n",
    "bl1.feedforward()\n",
    "show_nn(bl1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "#show_nn(bl1)\n",
    "#copy weight matrix\n",
    "bl1_mirr.wi=bl1.wo.T\n",
    "bl1_mirr.wo=bl1.wi.T\n",
    "#target as inputs\n",
    "bl1_mirr.train(targets_flip,inputs_flip)\n",
    "bl1_mirr.feedforward()\n",
    "#show_nn(bl1_mirr)\n",
    "\n",
    "bl1.wi=bl1_mirr.wo.T\n",
    "bl1.wo=bl1_mirr.wi.T\n",
    "bl1.inode=inputs\n",
    "bl1.feedforward()\n",
    "\n",
    "#bl1.train(inputs_flip,targets_flip)\n",
    "show_nn(bl1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, True, False]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "targets_flip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "bl1.inode=[True,True,True]\n",
    "bl1.feedforward()\n",
    "show_nn(bl1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "bl1.inode=inputs\n",
    "bl1.feedforward()\n",
    "show_nn(bl1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "12\n",
      "19\n",
      "18\n",
      "11\n",
      "20\n",
      "24\n",
      "15\n",
      "23\n",
      "22\n",
      "17\n",
      "15\n",
      "13\n",
      "21\n",
      "22\n",
      "17\n",
      "16\n",
      "14\n",
      "19\n",
      "19\n",
      "12\n",
      "25\n",
      "17\n",
      "26\n",
      "20\n",
      "21\n",
      "21\n",
      "19\n",
      "16\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "\n",
    "for i in range(0,30):\n",
    "    right=0\n",
    "    for j in range(0,100):\n",
    "        x=(np.random.random((1,10))>0.5)[0]\n",
    "        y=(np.random.random((1,10))>0.5)[0]\n",
    "        temp=boolean.qtimes_bv_bv(x,y)\n",
    "        if temp.count(True)>2*temp.count(False):\n",
    "            right+=1\n",
    "    print (right)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
